// src/main/repositories/ResourceRepository.js
import { PrismaClient } from '@prisma/client'

/**
 * Prisma 客户端单例管理
 */
class PrismaManager {
  static #instance = null

  /**
   * 初始化数据库连接（单例模式）
   * @param {string} databaseUrl 数据库连接URL
   * @returns {PrismaClient} Prisma客户端实例
   */
  static initialize(databaseUrl) {
    if (this.#instance) {
      return this.#instance
    }

    this.#instance = new PrismaClient({
      datasources: { db: { url: databaseUrl } }
    })

    return this.#instance
  }

  /**
   * 验证数据库连接状态
   * @returns {Promise<{ success: boolean, message?: string }>}
   */
  static async verifyConnection() {
    try {
      if (!this.#instance) {
        throw new Error('数据库未初始化')
      }

      // 执行简单查询验证连接
      await this.#instance.$queryRaw`SELECT 1`
      return { success: true, message: '数据库连接成功' }
    } catch (error) {
      return {
        success: false,
        message: `连接验证失败: ${error.message}`
      }
    }
  }

  /**
   * 获取已初始化的 Prisma 客户端实例
   * @returns {PrismaClient} Prisma 客户端实例
   * @throws {Error} 如果 Prisma 客户端尚未初始化
   */
  static getInstance() {
    if (!this.#instance) {
      throw new Error('Prisma Client 未初始化')
    }
    return this.#instance
  }
}

/**
 * 资源仓库类
 * 封装了对 Resource 模型的所有数据库操作
 */
class ResourceRepository {
  /**
   * 创建单个资源
   * @param {Object} data - 资源数据
   * @returns {Promise<Object>} 创建成功的资源对象
   */
  static async create(data) {
    if (!data || typeof data !== 'object') {
      throw new Error('无效的资源数据')
    }

    const client = PrismaManager.getInstance()
    return client.t_resource.create({ data })
  }

  /**
   * 批量创建资源
   * @param {Array<Object>} dataArray - 资源数据数组
   * @param {boolean} [skipDuplicates=true] - 是否跳过重复项
   * @returns {Promise<{count: number, errors: string[]}>} 批量创建结果
   */
  static async createMany(dataArray, skipDuplicates = true) {
    if (!Array.isArray(dataArray)) {
      throw new Error('资源数据必须是数组')
    }

    const client = PrismaManager.getInstance()

    try {
      return await client.t_resource.createMany({
        data: dataArray,
        skipDuplicates
      })
    } catch (error) {
      return this.#fallbackCreateMany(dataArray, error)
    }
  }

  /**
   * 回退批量创建方法
   * @private
   */
  static async #fallbackCreateMany(dataArray, originalError) {
    // 检查是否因为MySQL版本不支持createMany方法
    const isUnsupportedError =
      originalError.code === 'P1012' || originalError.message.includes('createMany')

    if (!isUnsupportedError) {
      throw originalError
    }

    console.warn('createMany 方法不支持，回退到循环创建...')

    let count = 0
    const errors = []

    for (const data of dataArray) {
      try {
        await this.create(data)
        count++
      } catch (error) {
        const t_resourceId = data.id || data.title || '未知资源'
        console.error(`创建资源 "${t_resourceId}" 失败:`, error)
        errors.push(`资源创建失败: ${t_resourceId} - ${error.message}`)
      }
    }

    return { count, errors }
  }

  /**
   * 查找多个资源
   * @param {Object} [filters={}] - 查询条件
   * @returns {Promise<Array<Object>>} 资源对象数组
   */
  static async findMany(filters = {}) {
    const client = PrismaManager.getInstance()
    return client.t_resource.findMany({ where: filters })
  }

  /**
   * 按ID查找单个资源
   * @param {number} id - 资源ID
   * @returns {Promise<Object|null>} 资源对象或null
   */
  static async findById(id) {
    if (!id || isNaN(Number(id))) {
      throw new Error('无效的资源ID')
    }

    const client = PrismaManager.getInstance()
    return client.t_resource.findUnique({ where: { id: Number(id) } })
  }

  /**
   * 更新资源
   * @param {number} id - 资源ID
   * @param {Object} data - 更新数据
   * @returns {Promise<Object>} 更新后的资源对象
   */
  static async update(id, data) {
    if (!id || isNaN(Number(id))) {
      throw new Error('无效的资源ID')
    }

    if (!data || typeof data !== 'object') {
      throw new Error('无效的更新数据')
    }

    const client = PrismaManager.getInstance()
    return client.t_resource.update({
      where: { id: Number(id) },
      data
    })
  }

  /**
   * 删除资源
   * @param {number} id - 资源ID
   * @returns {Promise<Object>} 删除的资源对象
   */
  static async delete(id) {
    if (!id || isNaN(Number(id))) {
      throw new Error('无效的资源ID')
    }

    const client = PrismaManager.getInstance()
    return client.t_resource.delete({ where: { id: Number(id) } })
  }
}

// 统一导出
export { PrismaManager, ResourceRepository }

// 可选：默认导出资源仓库
export default ResourceRepository
